package com.ruoyi.swap.openapi.currencyPair.controller;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.swap.constants.SwapMonitorConstants;
import com.ruoyi.swap.openapi.currencyPair.domain.SwapCurrencyPair;
import com.ruoyi.swap.realtime.kline.service.ISwapKlineRealtimeDataService;
import com.ruoyi.util.LarkNewRobotUtils;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 合约-同步所有交易对
 */
@Controller
@Component("SwapCurrencyPair")
public class SwapcurrencyPair {

    private static final Logger log = LoggerFactory.getLogger(SwapcurrencyPair.class);

    @Autowired
    private ISwapKlineRealtimeDataService swapKlineRealtimeDataService;

    @Value("${my.secret.accesskey}")
    private String ACCESS_KEY;

    @Value("${my.secret.secretkey}")
    private String SECRET_KEY;

    @Value("${my.lark.newlark}")
    private String newlark;

    @Value("")
    private String url;

    public void compareSwapCurrenyPairs() throws IOException, InterruptedException {
        // 1. 从API获取最新的合约交易对列表
        List<String> apiPairList = getApiCurrencyPairs();
        if (apiPairList.isEmpty()) {
            log.warn("从API获取的合约交易对列表为空，跳过本次同步。");
            return;
        }

        // 2. 从数据库获取【所有】合约交易对，并处理成Map以便快速查找
        List<SwapCurrencyPair> allDbPairs = swapKlineRealtimeDataService.queryAllDatabasedata();

        // 使用格式化后的 currency_pair 作为 key
        Map<String, SwapCurrencyPair> dbPairMap = allDbPairs.stream()
                .collect(Collectors.toMap(SwapCurrencyPair::getCurrencyPair, pair -> pair, (existing, replacement) -> existing));

        log.info("API合约交易对数量: {}, 数据库总合约交易对数量: {}", apiPairList.size(), dbPairMap.size());

        // 3. 遍历API列表，处理新增和重新激活的交易对
        for (String apiPair : apiPairList) {
            // 将API返回的原始symbol也进行格式化，以便在Map中查找
            String formattedApiPair = formatCurrencyPair(apiPair);
            SwapCurrencyPair existingPair = dbPairMap.get(formattedApiPair);

            if (existingPair == null) {
                // 情况A：数据库中完全不存在，是全新交易对 -> 新增
                String notice = "【合约交易】新交易对上线，名称：" + apiPair;
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                swapKlineRealtimeDataService.addnewcurrency_pair(formattedApiPair, apiPair);

            } else if (!existingPair.isStatues()) {
                // 情况B：数据库中存在，但状态为0（已下线） -> 重新激活
                String notice = "【合约交易】交易对重新上线，名称：" + existingPair.getApiCurrencyPair();
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                swapKlineRealtimeDataService.reactivateCurrencyPair(formattedApiPair);
            }
            // 情况C：数据库中存在且状态为1，则无需任何操作
        }

        // 4. 遍历数据库中的【所有】交易对，处理需要下线的
        for (SwapCurrencyPair dbPair : allDbPairs) {
            if (dbPair.isStatues() && !apiPairList.contains(dbPair.getApiCurrencyPair())) {
                // 如果一个交易对在数据库中是活跃的，但在最新的API列表中找不到，说明它已被下线
                String notice = "【合约交易】交易对下线，名称：" + dbPair.getApiCurrencyPair();
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                swapKlineRealtimeDataService.deletenewcurrency_pair(dbPair.getCurrencyPair()); // 使用格式化的key进行软删除
            }
        }

        log.info("============ChainUp生产巡检-合约交易对变更执行完成============");
    }


    private String formatCurrencyPair(String apiPair) {
        if (apiPair == null || apiPair.isEmpty()) {
            return "";
        }
        return apiPair.toLowerCase().replace("-", "_");
    }

    /**
     * 封装了从API获取和解析交易对的逻辑
     * @return API返回的原始交易对(symbol)列表
     */
    private List<String> getApiCurrencyPairs() {
        List<String> currencyPairList = new ArrayList<>();
        OkHttpClient client = new OkHttpClient().newBuilder().build();
        try {
            Request request = new Request.Builder()
                    .url(SwapMonitorConstants.SWAP_CURRENCY_PAIR_URL)
                    .get()
                    .build();
            Response response = client.newCall(request).execute();
            String responseBody = response.body().string();

            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode rootNode = objectMapper.readTree(responseBody);
            JsonNode contractsNode = rootNode.get("contracts");

            if (contractsNode != null && contractsNode.isArray()) {
                for (JsonNode element : contractsNode) {
                    if (element.has("symbol")) {
                        String symbol = element.get("symbol").asText();
                        if (symbol != null && !symbol.isEmpty() && symbol.contains("-SWAP-")) {
                            currencyPairList.add(symbol);
                        }
                    }
                }
            } else {
                log.warn("未能从API响应中找到 'contracts' 数组!");
            }
        } catch (IOException e) {
            log.error("获取或解析合约交易对时发生IO异常", e);
        } catch (Exception e) {
            log.error("获取或解析合约交易对时发生未知异常", e);
        }
        return currencyPairList;
    }
}